package com.tiny.conf.core.util;

/**
 *该Java类FieldReflectionUtil提供了一系列方法用于将字符串解析为不同的数据类型，包括字节、布尔值、短整型、整型、长整型、浮点型、双精度浮点型。主要功能包括：
 * 基本数据类型解析：如parseByte、parseBoolean、parseInt、parseShort、parseLong、parseFloat、parseDouble方法分别将字符串转换为对应的Java基本数据类型。
 * 在转换过程中，会先去除字符串中的全角空格字符，然后使用相应的解析方法。如果字符串不能被成功解析为目标类型，会抛出自定义的异常RuntimeException。
 * 通用解析方法：parseValue方法根据提供的Class<?>对象（即目标数据类型）和字符串值，动态选择合适的解析方法进行转换。
 * 支持的类型包括String、Boolean、Short、Integer、Long、Float、Double。对于不支持的数据类型，会抛出RuntimeException。
 * 异常处理：在解析过程中，如果遇到不合法的输入或不支持的数据类型，会抛出异常，以便调用者能够处理不合规的配置或输入情况。
 * 工具类特性：FieldReflectionUtil被设计为一个工具类，通过提供静态方法方便调用，且自身构造方法不可访问，确保该类不能被实例化。
 */
public final class FieldReflectionUtil {

    private FieldReflectionUtil(){}

    public static Byte parseByte(String value) {
        try {
            value = value.replaceAll("　", "");
            return Byte.valueOf(value);
        } catch(NumberFormatException e) {
            throw new RuntimeException("parseByte but input illegal input=" + value, e);
        }
    }

    public static Boolean parseBoolean(String value) {
        value = value.replaceAll("　", "");
        if (Boolean.TRUE.toString().equalsIgnoreCase(value)) {
            return Boolean.TRUE;
        } else if (Boolean.FALSE.toString().equalsIgnoreCase(value)) {
            return Boolean.FALSE;
        } else {
            throw new RuntimeException("parseBoolean but input illegal input=" + value);
        }
    }

    public static Integer parseInt(String value) {
        try {
            value = value.replaceAll("　", "");
            return Integer.valueOf(value);
        } catch(NumberFormatException e) {
            throw new RuntimeException("parseInt but input illegal input=" + value, e);
        }
    }

    public static Short parseShort(String value) {
        try {
            value = value.replaceAll("　", "");
            return Short.valueOf(value);
        } catch(NumberFormatException e) {
            throw new RuntimeException("parseShort but input illegal input=" + value, e);
        }
    }

    public static Long parseLong(String value) {
        try {
            value = value.replaceAll("　", "");
            return Long.valueOf(value);
        } catch(NumberFormatException e) {
            throw new RuntimeException("parseLong but input illegal input=" + value, e);
        }
    }

    public static Float parseFloat(String value) {
        try {
            value = value.replaceAll("　", "");
            return Float.valueOf(value);
        } catch(NumberFormatException e) {
            throw new RuntimeException("parseFloat but input illegal input=" + value, e);
        }
    }

    public static Double parseDouble(String value) {
        try {
            value = value.replaceAll("　", "");
            return Double.valueOf(value);
        } catch(NumberFormatException e) {
            throw new RuntimeException("parseDouble but input illegal input=" + value, e);
        }
    }


    /**
     * 参数解析 （支持：Byte、Boolean、String、Short、Integer、Long、Float、Double、Date）
     *
     * @param fieldType
     * @param value
     * @return
     */
    public static Object parseValue(Class<?> fieldType, String value) {
        // Class<?> fieldType = field.getType();	// Field field

        if(value==null || value.trim().length()==0)
            return null;
        value = value.trim();

        if (String.class.equals(fieldType)) {
            return value;
        } else if (Boolean.class.equals(fieldType) || Boolean.TYPE.equals(fieldType)) {
            return parseBoolean(value);
        } /*else if (Byte.class.equals(fieldType) || Byte.TYPE.equals(fieldType)) {
			return parseByte(value);
		}  else if (Character.class.equals(fieldType) || Character.TYPE.equals(fieldType)) {
			 return value.toCharArray()[0];
		}*/ else if (Short.class.equals(fieldType) || Short.TYPE.equals(fieldType)) {
            return parseShort(value);
        } else if (Integer.class.equals(fieldType) || Integer.TYPE.equals(fieldType)) {
            return parseInt(value);
        } else if (Long.class.equals(fieldType) || Long.TYPE.equals(fieldType)) {
            return parseLong(value);
        } else if (Float.class.equals(fieldType) || Float.TYPE.equals(fieldType)) {
            return parseFloat(value);
        } else if (Double.class.equals(fieldType) || Double.TYPE.equals(fieldType)) {
            return parseDouble(value);
        } else {
            throw new RuntimeException("illeagal conf data type, type=" + fieldType);
        }
    }

}